Software applications can interact with a wide variety of files. A software development tool or a file manager represent just two such examples. Users of these applications can interact with the files displayed in the interfaces in different respects; one way of doing so is by the relevance of file types in a given application's behavior. For example, file types are used by operating systems to determine how to open files. In addition, file types are used by editors to determine how to format or display files, and so forth.
As the number of file types a user works with increases, a user may become overwhelmed. In particular, tasks that become more difficult with an increase in file type variety include: navigation between open files from a collection, addition of new files into a collection and identification of individual files included in the collection.
For example, it is a common scenario when interfacing with a file system or when working in a development environment to be presented with a large list of file names. For instance, a user can open a file manager, which presents scores of files that exist in a particular directory. Depending on the view, these files can be represented by predefined icons or thumbnails. As another example, a developer utilizing an integrated development environment, or an editor or another application, can have many files open in the editor with each open file displayed as a selectable tab on a navigation bar of the editor.
In either case, a situation can arise in which a user desires to quickly locate a particular file. In conventional systems, it is often the case that the user is unable to do so without close inspection of individual file names. Compounding the difficulty of this task, many files can actually have the same file name differing only in the file extension (i.e. the same prefix, but different extension). For example, a web developer might desire to change the style of a webpage and therefore search for a “.css” file representing a cascading style sheet file type, and search specifically for the file named: “main.css”. However, within the same view, there might also be several other files named “main.htm”, “main.js” and so on. Inadequate scrutiny of the file extensions results in errors while attempting to select the desired file.
Furthermore, many modern systems no longer display file extensions in certain user interfaces or views of a given user interface, opting instead for display of the prefix (e.g., “main”) along with a registered icon or thumbnail. However, in either case, whether a user distinguishes based upon a file name or a file name prefix in conjunction with an icon, the task remains largely inefficient. In other words, neither file names nor icons have been shown to optimally enable users to quickly distinguish between file types.
The above-described deficiencies of today's techniques are merely intended to provide an overview of some of the problems of conventional systems, and are not intended to be exhaustive. Other problems with conventional systems and corresponding benefits of the various non-limiting embodiments described herein may become further apparent upon review of the following description.